home *** CD-ROM | disk | FTP | other *** search
/ AOL File Library: 2,801 to 2,900 / aol-file-protocol-4400-2801-to-2900.zip / AOLDLs / C++ Files Library / SK (Sockects) 1.4.1 r2 / SK v1.4.1 r2.sit / SK 1.4.1 r2 / SK / SK Sources / SK_UDP.cc < prev    next >
Text File  |  1994-06-13  |  19KB  |  775 lines
  1. /***************************************************************************
  2. * 
  3. * 
  4. * Copyright ⌐ 1992-1994 Matthias Neeracher and the Decision Systems Group
  5. * 
  6. * Permission is granted to anyone to use this software for any purpose on
  7. * any computer system, and to redistribute it freely, subject to the
  8. * following restrictions:
  9. * 
  10. * 1) The authors and the Decision Systems Group are not responsible for 
  11. *    the direct or indirect consequences of use of this software, no matter 
  12. *    how awful, even if they arise from defects in the software itself.
  13. *    This restriction applies to the use of this and any derived source code 
  14. *    and also to the use of all binary produced from this and any derived 
  15. *    source code.
  16. * 2) The origin and copyrights of this software must not be misrepresented, 
  17. *    either by explicit claim or by omission or alteration of copyright or
  18. *    authorship header information in this file or in any derived file.
  19. * 3) Altered or derived versions must be plainly marked as such, and must not
  20. *    be misrepresented as being the original software.
  21. * 
  22. * We encourage users of this software to provide feedback, bug fixes,
  23. * and enhancements to the authors for incorporation into future releases.
  24. *
  25. * ==========================================================================
  26. * 
  27. * FILE: SK_INET.cc
  28. * 
  29. * AUTHOR: Matthias Neeracher and Stephan Deibel
  30. * 
  31. * CREATION DATE: 12Aug92
  32. * 
  33. * VERSION: 13Jun94
  34. * 
  35. * DESCRIPTION: 
  36. *
  37. * UDP datagram sockets implementation
  38. * 
  39. * NOTES: 
  40. * 
  41. * 0) This code was derived from Matthias Neerarcher's GUSI 1.1.0 and
  42. *    the socket library written by Charlie Reiman (creiman@ncsa.uiuc.edu)
  43. *    and Tom Milligan (milligan@madhaus.utcs.utoronto.ca); Copyrights
  44. *    are subject to this origin.
  45. *
  46. * MODIFICATIONS: 
  47. * --------------------------------------------------------------------------
  48. * Date     Name      Description of modification
  49. * --------------------------------------------------------------------------
  50. * 
  51. * 16Aug92    MN       Split off
  52. * 25Aug92    MN       Started putting some real work in
  53. * 14Sep92    MN       select() didn't return enough goodies.
  54. * 13Jul93    SD       Port to THINK C++ 6.0
  55. * 21Jul93    SD       Subsetted to only TCP/UDP, applied DSG naming 
  56. *                    conventions and commenting guidelines, and
  57. *                    changed name to "SK" for clear distinction from
  58. *                    the GUSI code from which this was derived
  59. * 13Jun94   SD       Updated based on relevant changes to GUSI (through 1.4.1)
  60. * 
  61. */
  62.  
  63.  
  64. #include "SK_INET_P.hh"
  65.  
  66.  
  67. /**************************************************************************/ 
  68. /**************************************************************************/ 
  69. /* Completion procedures */
  70.  
  71.  
  72. // Need to declare all completion procedures a "C" routines and not "C++"
  73. // routines due to a bug in the THINK C++ 6.0 compiler.
  74.  
  75. extern "C" {
  76.  
  77.  
  78. /*************************************************************************** *
  79. * FUNCTION:
  80. *
  81. * udp_flush_read_ahead_done
  82. *
  83. * DESCRIPTION:
  84. *
  85. * Flush read-ahead completion procedure
  86. *
  87. * PARAMETERS:
  88. *
  89. * CSK_AnnotatedPB *        -- Parameter block associated with completed flush read ahead
  90. *
  91. */
  92.  
  93. void udp_flush_read_ahead_done(CSK_AnnotatedPB *pb)
  94. {
  95.     UDPiopb * udp = pb->UDP();
  96.  
  97.     // Check for nasty error that once plagued us (will be removed eventually)
  98.     ASSERT(udp->ioResult != inProgress);
  99. }
  100.  
  101.  
  102. /*************************************************************************** *
  103. * FUNCTION:
  104. *
  105. * udp_read_ahead_done
  106. *
  107. * DESCRIPTION:
  108. *
  109. * Read-ahead completion procedure
  110. *
  111. * PARAMETERS:
  112. *
  113. * CSK_AnnotatedPB *        -- Parameter block associated with completed read ahead
  114. *
  115. */
  116.  
  117. void udp_read_ahead_done(CSK_AnnotatedPB *pb)
  118. {
  119.     CSK_UDPSocket * sock = (CSK_UDPSocket *) pb->Owner();
  120.     UDPiopb * udp = pb->UDP();
  121.  
  122.     if (!udp->ioResult) {
  123.         sock->fReceiveBuf = udp->csParam.receive.rcvBuff;
  124.         sock->fBytesReceived = udp->csParam.receive.rcvBuffLen;
  125.     } else {
  126.         sock->fReceiveBuf = nil;
  127.         sock->fBytesReceived = 0;
  128.     }
  129.     sock->fLastAsyncErr                         = udp->ioResult;
  130.     sock->fPeerSocketAddress.sin_len             = sizeof(struct sockaddr_in);
  131.     sock->fPeerSocketAddress.sin_family         = AF_INET;
  132.     sock->fPeerSocketAddress.sin_addr.s_addr    = udp->csParam.receive.remoteHost;
  133.     sock->fPeerSocketAddress.sin_port            = udp->csParam.receive.remotePort;
  134.  
  135.     // Check for nasty error that once plagued us (will be removed eventually)
  136.     ASSERT(udp->ioResult != inProgress);
  137. }
  138.  
  139.  
  140. /*************************************************************************** *
  141. * FUNCTION:
  142. *
  143. * udp_send_done
  144. *
  145. * DESCRIPTION:
  146. *
  147. * UDP send completion procedure
  148. *
  149. * PARAMETERS:
  150. *
  151. * CSK_AnnotatedPB *        -- Parameter block associated with completed send
  152. *
  153. */
  154.  
  155. void udp_send_done(CSK_AnnotatedPB *pb)
  156. {    
  157.     UDPiopb * udp = pb->UDP();
  158.     
  159.     ((SKt_MiniWds *)udp->csParam.send.wdsPtr)->terminus    = udp->ioResult;
  160.     ((SKt_MiniWds *)udp->csParam.send.wdsPtr)->ptr        = nil;
  161.  
  162.     // Check for nasty error that once plagued us (will be removed eventually)
  163.     ASSERT(udp->ioResult != inProgress);
  164. }
  165.  
  166.  
  167. } /* extern "C" */
  168.  
  169.  
  170. /**************************************************************************/ 
  171. /**************************************************************************/ 
  172. /* CSK_UDPSocket members */
  173.  
  174.  
  175. /*************************************************************************** *
  176. * FUNCTION:
  177. *
  178. * CSK_UDPSocket::CSK_UDPSocket
  179. *
  180. * DESCRIPTION:
  181. *
  182. * Constructor for this class
  183. *
  184. */
  185.  
  186. CSK_UDPSocket::CSK_UDPSocket()
  187.     :    CSK_INETSocket()
  188. {
  189.     fSocketState = SKk_STATE_NO_STREAM;
  190. }
  191.  
  192.  
  193. /*************************************************************************** *
  194. * FUNCTION:
  195. *
  196. * CSK_UDPSocket::CSK_UDPSocket
  197. *
  198. * DESCRIPTION:
  199. *
  200. * Constructor for this class
  201. *
  202. * PARAMETERS:
  203. *
  204. * StreamPtr            -- The stream to use with this UDP socket
  205. *
  206. */
  207.  
  208. CSK_UDPSocket::CSK_UDPSocket(StreamPtr stream)
  209.     :    CSK_INETSocket(stream)
  210. {
  211.     OSErr            err;
  212.     UDPiopb *    pb;
  213.  
  214.     pb = GetPB();
  215.     pb->ioCompletion = UDPIOCompletionProc(udp_read_ahead_done);
  216.     pb->csCode = UDPRead;
  217.     pb->csParam.receive.timeOut            = 0 /* infinity */;
  218.     pb->csParam.receive.secondTimeStamp    = 0 /* must be zero */;
  219.  
  220.     /* We know that there is a read pending, so we make a synchronous call */
  221.     
  222.     err = PBControlSync(ParmBlkPtr(pb));
  223.  
  224.     // Check for nasty error that once plagued us (will be removed eventually)
  225.     ASSERT(pb->ioResult != inProgress);
  226.  
  227.     if (err != 0)
  228.         SK_TCPError(err);
  229.     
  230.     if (!pb->ioResult) {
  231.         fReceiveBuf    = pb->csParam.receive.rcvBuff;
  232.         fBytesReceived        = pb->csParam.receive.rcvBuffLen;
  233.     } else {
  234.         fReceiveBuf    = nil;
  235.         fBytesReceived        = 0;
  236.     }
  237.     fLastAsyncErr                         =    pb->ioResult;
  238.     fPeerSocketAddress.sin_len             =     sizeof(struct sockaddr_in);
  239.     fPeerSocketAddress.sin_family         =     AF_INET;
  240.     fPeerSocketAddress.sin_addr.s_addr    =    pb->csParam.receive.remoteHost;
  241.     fPeerSocketAddress.sin_port            =    pb->csParam.receive.remotePort;
  242. }
  243.  
  244.  
  245. /*************************************************************************** *
  246. * FUNCTION:
  247. *
  248. * CSK_UDPSocket::~CSK_UDPSocket
  249. *
  250. * DESCRIPTION:
  251. *
  252. * Destructor for this class
  253. *
  254. */
  255.  
  256. CSK_UDPSocket::~CSK_UDPSocket()
  257. {
  258.     UDPiopb * pb;
  259.     
  260.     if (fSocketState == SKk_STATE_NO_STREAM)
  261.         return;
  262.     
  263.     pb = GetPB();    
  264.     pb->csCode = UDPRelease;
  265.     
  266.     if (!PBControlSync(ParmBlkPtr(pb)))
  267.         DisposPtr(pb->csParam.create.rcvBuff);
  268.  
  269.     // Check for nasty error that once plagued us (will be removed eventually)
  270.     ASSERT(pb->ioResult != inProgress);
  271. }
  272.  
  273.  
  274. /*************************************************************************** *
  275. * FUNCTION:
  276. *
  277. * CSK_UDPSocket::GetPB
  278. *
  279. * DESCRIPTION:
  280. *
  281. * Get a UDP io parameter block for use with this UDP socket.  The
  282. * parameter block is obtained from the SKg_INETSockets domain object
  283. * and is set up for use specifically with this socket.
  284. *
  285. * RETURNS:
  286. *
  287. * UDPiopb *            -- The UDP io parameter block
  288. *
  289. */
  290.  
  291. UDPiopb * CSK_UDPSocket::GetPB()
  292. {
  293.     CSK_AnnotatedPB *    pb        =    SKg_INETSockets.GetPB();
  294.     pb->UDP()->ioCRefNum =    SKg_INETSockets.Driver();
  295.     pb->UDP()->udpStream    =    fStream;
  296.     
  297.     pb->SetOwner(this);
  298.     
  299.     return pb->UDP();
  300. }
  301.  
  302.  
  303. /*************************************************************************** *
  304. * FUNCTION:
  305. *
  306. * CSK_UDPSocket::Available
  307. *
  308. * DESCRIPTION:
  309. *
  310. * Return number of bytes of unread data available on this socket
  311. *
  312. * RETURNS:
  313. *
  314. * u_long        -- The number of unread bytes available
  315. *
  316. */
  317.  
  318. unsigned long CSK_UDPSocket::Available()
  319. {
  320.     return (fLastAsyncErr == inProgress) ? 0 : fBytesReceived;
  321. }
  322.  
  323.  
  324. /*************************************************************************** *
  325. * FUNCTION:
  326. *
  327. * CSK_UDPSocket::NewStream
  328. *
  329. * DESCRIPTION:
  330. *
  331. * ???
  332. *
  333. * RETURNS:
  334. *
  335. * int            -- Error value (0 = no error)
  336. *
  337. */
  338.  
  339. int CSK_UDPSocket::NewStream()
  340. {
  341.     OSErr err;
  342.     UDPiopb * pb;
  343.  
  344.     pb = GetPB();
  345.     pb->csCode = UDPCreate;
  346.     pb->csParam.create.rcvBuff = (char *)NewPtr(SKk_StreamBufferSize);
  347.     pb->csParam.create.rcvBuffLen = SKk_StreamBufferSize;
  348.     pb->csParam.create.notifyProc = NULL;
  349.     pb->csParam.create.localPort = fMySocketAddress.sin_port;
  350.     
  351.     err = PBControlSync(ParmBlkPtr(pb));
  352.  
  353.     // Check for nasty error that once plagued us (will be removed eventually)
  354.     ASSERT(pb->ioResult != inProgress);
  355.  
  356.     if (err != 0)
  357.         return SK_TCPError(err);
  358.         
  359.     fStream         = pb->udpStream;
  360.     fMySocketAddress.sin_port = pb->csParam.create.localPort;
  361.     
  362.     fSocketState     = SKk_STATE_UNCONNECTED;
  363.     fBytesReceived     = 0;
  364.     fReceiveBuf     = nil;
  365.     fLastAsyncErr    = inProgress;
  366.  
  367.     return ReadAhead();
  368. }
  369.  
  370.  
  371. /*************************************************************************** *
  372. * FUNCTION:
  373. *
  374. * CSK_UDPSocket::FlushReadAhead
  375. *
  376. * DESCRIPTION:
  377. *
  378. * Flush the read-ahead buffer for this UDP socket
  379. *
  380. * RETURNS:
  381. *
  382. * int            -- Error value (0 = no error)
  383. *
  384. */
  385.  
  386. int CSK_UDPSocket::FlushReadAhead()
  387. {
  388.     OSErr            err;
  389.     UDPiopb *    pb;
  390.  
  391.     /* flush the read-ahead buffer if its not from our new friend */
  392.     pb = GetPB();
  393.     pb->ioCompletion = UDPIOCompletionProc(udp_flush_read_ahead_done);
  394.     pb->csCode = UDPBfrReturn;
  395.     pb->csParam.receive.rcvBuff    = fReceiveBuf;
  396.     fReceiveBuf    = nil;
  397.     fBytesReceived = 0;
  398.     
  399.     err = PBControlAsync(ParmBlkPtr(pb));
  400.  
  401.     if (err != 0)
  402.         return SK_TCPError(err);
  403.     else
  404.         return 0;
  405. }
  406.  
  407.  
  408. /*************************************************************************** *
  409. * FUNCTION:
  410. *
  411. * CSK_UDPSocket::ReadAhead
  412. *
  413. * DESCRIPTION:
  414. *
  415. * Start asyncronous read-ahead on this UDP socket
  416. *
  417. * RETURNS:
  418. *
  419. * int            -- Error value (0 = no error)
  420. *
  421. */
  422.  
  423. int CSK_UDPSocket::ReadAhead()
  424. {
  425.     OSErr            err;
  426.     UDPiopb *    pb;
  427.     
  428.     pb = GetPB();
  429.     pb->ioCompletion = UDPIOCompletionProc(udp_read_ahead_done);
  430.     pb->csCode = UDPRead;
  431.     pb->csParam.receive.timeOut            = 0 /* infinity */;
  432.     pb->csParam.receive.secondTimeStamp    = 0 /* must be zero */;
  433.     fLastAsyncErr = 1;
  434.     
  435.     err = PBControlAsync(ParmBlkPtr(pb));
  436.     if (err != 0)
  437.         return SK_TCPError(fLastAsyncErr = err);
  438.  
  439.     return 0;
  440. }
  441.  
  442. /*************************************************************************** *
  443. * FUNCTION:
  444. *
  445. * CSK_UDPSocket::getsockname
  446. *
  447. * DESCRIPTION:
  448. *
  449. * Returns the current name for the given socket.
  450. *
  451. * PARAMETERS:
  452. *
  453. * void *        -- Buffer space for returned name
  454. * int *            -- Buffer space for returned name length (should contain
  455. *                  maximum allowable return length initially)
  456. *
  457. * RETURNS
  458. *
  459. * int            -- 0 upon success; -1 upon failure
  460. *
  461. * The name and name length are returned in the provided buffer space.
  462. *
  463. */
  464.  
  465. int CSK_UDPSocket::getsockname(void *name, int *namelen)
  466. {
  467.     if (fSocketState == SKk_STATE_NO_STREAM)
  468.         if (NewStream())
  469.             return -1;
  470.  
  471.     return CSK_INETSocket::getsockname(name, namelen);
  472. }
  473.  
  474.  
  475. /*************************************************************************** *
  476. * FUNCTION:
  477. *
  478. * CSK_UDPSocket::connect
  479. *
  480. * DESCRIPTION:
  481. *
  482. * Initiate a connection on a MacTCP socket.
  483. *
  484. * This  call specifies the address to  which  datagrams
  485. * are  to  be  sent, and the only address from which datagrams
  486. * are to be received.  
  487. *             
  488. * PARAMETERS:
  489. *
  490. * void *            -- The internet address to connect to
  491. * int                -- The length of the above internet address structure
  492. *
  493. * RETURNS:
  494. *
  495. * If the connection or binding succeeds, then 0 is returned.
  496. * Otherwise a -1 is returned, and a more specific error code
  497. * is stored in errno:
  498. *        
  499. *     EAFNOSUPPORT      The address family in addr is not AF_INET.
  500. *        
  501. *    EHOSTUNREACH      The TCP connection came up half-way and 
  502. *                     then failed.
  503. *
  504. * NOTES:
  505. *
  506. * UDP sockets may use connect() multiple times to change
  507. * their association. UDP sockets may dissolve the association
  508. * by connecting to an invalid address, such as a null
  509. * address.
  510. *
  511. */
  512.  
  513. int CSK_UDPSocket::connect(void * address, int addrlen)
  514. {
  515.     struct sockaddr_in *    addr    = (struct sockaddr_in *) address;
  516.         
  517.     if (addrlen != sizeof(struct sockaddr_in))
  518.         return SK_Error(EINVAL);
  519.  
  520.     if (addr->sin_family != AF_INET)
  521.         return SK_Error(EAFNOSUPPORT);
  522.     
  523.     /* make the stream if its not made already */
  524.     if (fSocketState == SKk_STATE_NO_STREAM) {
  525.         if (NewStream())
  526.             return -1;
  527.     } else if (fReceiveBuf)
  528.         if (FlushReadAhead())
  529.             return -1;
  530.     
  531.     /* record our peer */
  532.     fPeerSocketAddress.sin_len = sizeof(struct sockaddr_in);
  533.     fPeerSocketAddress.sin_addr.s_addr = addr->sin_addr.s_addr;
  534.     fPeerSocketAddress.sin_port = addr->sin_port;
  535.     fPeerSocketAddress.sin_family = AF_INET;
  536.     fSocketState = SKk_STATE_CONNECTED;
  537.     
  538.     return 0;
  539. }
  540.  
  541.  
  542. /*************************************************************************** *
  543. * FUNCTION:
  544. *
  545. * CSK_UDPSocket::recvfrom
  546. *
  547. * DESCRIPTION:
  548. *
  549. * recvfrom() attempts to receive a message (ie a datagram) on this socket
  550. *
  551. * PARAMETERS:
  552. *
  553. * void *        -- Pointer to buffer for returned bytes
  554. * int            -- Maximum number of bytes to read
  555. * int            -- unused
  556. * void *        -- Pointer to memory for return value (address of sender)
  557. * int *            -- Pointer to memory for length of return value
  558. *
  559. * RETURNS:
  560. *
  561. * int            -- Error return (0 = no error), -1 = error in which case
  562. *                   a more specific error code is stored in the global errno:
  563. *
  564. *    ESHUTDOWN    The socket has been shutdown for receive operations.
  565. *
  566. * The bytes received are read into the given buffer.
  567. *
  568. * The internet address of the caller and the length of that address
  569. * are placed into the last two parameters (void * and int).
  570. *
  571. * NOTES:
  572. *
  573. * Typically, read() is used with a TCP stream and recv() with
  574. * UDP where the idea of a message makes more sense. But in fact,
  575. * read() and recv() are equivalent.
  576. *
  577. * Regardless of non-blocking status, if less data is available
  578. * than has been requested, only that much data is returned.
  579. *
  580. * If the socket is marked for non-blocking I/O, and the socket
  581. * is empty, the operation will fail with the error EWOULDBLOCK.
  582. * Otherwise, the operation will block until data is available
  583. * or an error occurs.
  584. *
  585. * A return value of zero indicates that the stream has been
  586. * closed and all data has already been read. ie. end-of-file.
  587. *
  588. */
  589.  
  590.  
  591. int CSK_UDPSocket::recvfrom(void * buffer, int buflen, int, void * from, int * fromlen)
  592. {
  593.     /* make the stream if its not made already */
  594.     if (fSocketState == SKk_STATE_NO_STREAM)
  595.         if (NewStream())
  596.             return -1;
  597.             
  598.     /* dont block a non-blocking socket */
  599.     if (fNonBlocking && fLastAsyncErr == 1) 
  600.         return SK_Error(EWOULDBLOCK);
  601.     
  602.     SPIN(fLastAsyncErr == 1, SKk_DGRAM_READ,0);
  603.  
  604.     if (fLastAsyncErr!=noErr)
  605.         return SK_TCPError(fLastAsyncErr);
  606.  
  607.     /* return the data to the user - truncate the packet if necessary */
  608.     buflen = MIN(buflen,fBytesReceived);    
  609.     BlockMove(fReceiveBuf, buffer, buflen);
  610.  
  611.     if (from && *fromlen >= sizeof(struct sockaddr_in)) {
  612.         *(struct sockaddr_in *) from = fPeerSocketAddress;
  613.         *fromlen = sizeof (struct sockaddr_in);
  614.     }    
  615.     
  616.     /* continue the read-ahead - errors which occur */
  617.     /* here will show up next time around */
  618.     
  619.     FlushReadAhead();
  620.     ReadAhead();
  621.     
  622.     return buflen;
  623. }
  624.  
  625. /*************************************************************************** *
  626. * FUNCTION:
  627. *
  628. * CSK_UDPSocket::sendto
  629. *
  630. * DESCRIPTION:
  631. *
  632. * sendto() is used to transmit a message from this socket to another socket.
  633. *
  634. * PARAMETERS:
  635. *
  636. * void *        -- Pointer to buffer containing bytes to send
  637. * int            -- The number of bytes to send
  638. * int            -- Flags (???)
  639. * void *        -- Pointer to internet address to send to
  640. * int             -- Length of above internet address structure
  641. *
  642. * RETURNS:
  643. *
  644. * This call returns the number of bytes sent, or -1 if an error occurred,
  645. * in which case the global errno contains a more detailed error value:
  646. *
  647. *     EINVAL        The sum of the iov_len values in the iov array was
  648. *                greater than 65535 (TCP) or 65507 (UDP) or there
  649. *                were too many entries in the array (16 for TCP or
  650. *                6 for UDP).
  651. *
  652. *     ESHUTDOWN    The socket has been shutdown for send operations.
  653. *
  654. *     EMSGSIZE    The message is too big to send in one datagram. (UDP)
  655. *
  656. *     ENOBUFS        The transmit queue is full. (UDP)
  657. *
  658. * The bytes received are read into the given buffer.
  659. *
  660. * NOTES:
  661. *
  662. * Typically, write() is used with a TCP stream and send() with
  663. * UDP where the idea of a message makes more sense. But in fact,
  664. * write() and send() are equivalent.
  665. *
  666. * Write() and send() operations are not considered complete
  667. * until all data has been sent and acknowledged.
  668. *
  669. * The message must be short enough to fit into one datagram.
  670. *        
  671. * Buffer space must be available to hold the message to be 
  672. * transmitted, regardless of its non-blocking I/O state.
  673. *
  674. */
  675.  
  676. int CSK_UDPSocket::sendto(void * buffer, int count, int, void * to, int)
  677. {
  678.     SKt_MiniWds      awds;
  679.     OSErr        err;
  680.     UDPiopb *    pb;
  681.  
  682.     /* make the stream if its not made already */
  683.     if (fSocketState == SKk_STATE_NO_STREAM)
  684.         if (NewStream())
  685.             return -1;
  686.     
  687.     if (count > SKk_UDPMaxMessageSize)
  688.         return SK_Error(EMSGSIZE);
  689.         
  690.     awds.terminus = 0;
  691.     awds.length = count;
  692.     awds.ptr = (char *) buffer;
  693.     
  694.     // if no address passed, hope we have one already in fPeerSocketAddress field
  695.     if (to == NULL)
  696.         if (fPeerSocketAddress.sin_len)
  697.             to = &fPeerSocketAddress;
  698.         else
  699.             return SK_Error(EHOSTUNREACH);
  700.     
  701.     pb = GetPB();
  702.     pb->ioCompletion = UDPIOCompletionProc(udp_send_done);
  703.     pb->csCode = UDPWrite;
  704.     pb->csParam.send.remoteHost = ((struct sockaddr_in *)to)->sin_addr.s_addr;
  705.     pb->csParam.send.remotePort = ((struct sockaddr_in *)to)->sin_port;
  706.     pb->csParam.send.wdsPtr = (Ptr)&awds;
  707.     pb->csParam.send.checkSum = true;
  708.     pb->csParam.send.sendLength = 0 /* must be zero */;
  709.     
  710.     err = PBControlAsync(ParmBlkPtr(pb));
  711.  
  712.     if (err != 0)
  713.         return SK_TCPError(err);
  714.     
  715.     // get sneaky. compl. proc sets ptr to nil on completion, and puts result code in
  716.     // terminus field.
  717.     
  718.     SPIN(awds.ptr != NULL, SKk_DGRAM_WRITE, count);
  719.     
  720.     if (awds.terminus < 0)
  721.         return SK_TCPError(awds.terminus);
  722.     else
  723.         return count;
  724. }
  725.  
  726.  
  727. /*************************************************************************** *
  728. * FUNCTION:
  729. *
  730. * CSK_UDPSocket::select
  731. *
  732. * DESCRIPTION:
  733. *
  734. * Select read/write/exception abilities for this socket (???)
  735. *
  736. * PARAMETERS:
  737. *
  738. * Boolean *        -- Can read (???)
  739. * Boolean *     -- Can write (???)
  740. * Boolean *        -- Exception (???)
  741. *
  742. * RETURNS:
  743. *
  744. * int            -- ???
  745. *
  746. */
  747.  
  748. int CSK_UDPSocket::select(Boolean * canRead, Boolean * canWrite, Boolean * )
  749. {
  750.     int        goodies     =     0;
  751.  
  752.     if (canRead || canWrite)
  753.         if (fSocketState == SKk_STATE_NO_STREAM)
  754.             NewStream();
  755.                 
  756.     if (canRead)
  757.         if (fLastAsyncErr != 1) {
  758.             *canRead = true;
  759.             ++goodies;
  760.         }
  761.         
  762.     if (canWrite) {
  763.         *canWrite = true;
  764.         ++goodies;
  765.     }
  766.     
  767.     return goodies;
  768. }
  769.  
  770.  
  771.  
  772. /* end of SK_UCP.cc */
  773.  
  774.  
  775.